#ifndef __MY_UTIL__
#define __MY_UTIL__
#include<iostream>
#include<fstream>
#include<string>
#include<vector>
#include<sys/stat.h>
#include<experimental/filesystem>
#include<stdio.h>

namespace cloud{
	namespace fs=std::experimental::filesystem;
	class FileUtil{		
		private:
			std::string _filename;
		public:
			FileUtil(const std::string &filename):_filename(filename){}
			size_t FileSize()
			{
				struct stat st;
				if(stat(_filename.c_str(),&st)<0)
				{
					std::cout<<"get file size failed!\n";
					return 0;
				}
				return st.st_size;

			}
			time_t LastMTime(){
				struct stat st;
				if(stat(_filename.c_str(),&st)<0)
				{
					std::cout<<"get file last mtimg failed!\n";
					return -1;
				}
				return st.st_mtime;
			}
	
			time_t LastATime(){
				struct stat st;
				if(stat(_filename.c_str(),&st)<0)
				{
					std::cout<<"get file last atimg failed!\n";
					return -1;
				}
				return st.st_atime;
			}
			std::string FileName()
			{
				/*size_t pos;
				std::string filename="/"+_filename;
				pos=filename.find_last_of("/");
				if(pos==std::string::npos)
				{
					std::cout<<"find name failed!(util.hpp)\n";
					exit(1);
				}*/
				return fs::path(_filename).filename().string();
			}

			bool GetPosLen(std::string &body,size_t pos,size_t len)
			{
				if(this->FileSize()<pos+len)
				{
					std::cout<<"GetPosLen failed!\n";
					return false;
				}
				std::ifstream ifs;
				ifs.open(_filename,std::ios::binary);
				if(ifs.good()==false)
				{
					std::cout<<"open file failed!\n";
					return false;
				}
				ifs.seekg(pos,std::ios::beg);
				body.resize(len);
				ifs.read(&body[0],len);
				if(!ifs.good())
				{
					std::cout<<"read failede!\n";
					return false;
				}
				ifs.close();
				return true;
			}
			bool GetContent(std::string *body)
			{ 
				size_t fsize=this->FileSize();
				return GetPosLen(*body,0,fsize);
			}

			bool SetContent(const std::string &body)
			{
				std::ofstream ofs;
				ofs.open(_filename,std::ios::binary);
				if(ofs.is_open()==false)
				{
					std::cout<<"write open failede!\n";
					return false;
				}
				ofs.write(&body[0],body.size());
				if(!ofs.good())
				{
					std::cout<<"write failede!\n";
					return false;
				}
				ofs.close();
				return true;
			}

			bool Remove(){
				if(this->Exists()==false)
					return true;
				remove(_filename.c_str());
				return true;
			}
			bool Exists()
			{
				return fs::exists(_filename);
			}
			bool CreateDirectoryy()
			{	
				if(this->Exists()==true)
				{
					return true;	
				}		
				return fs::create_directories(_filename);
			}
			bool ScanDirectory(std::vector<std::string>* arry )
			{	
				CreateDirectoryy();

				for(auto& p:fs::directory_iterator(_filename))
				{	
					if(fs::is_directory(p))
						continue;
					arry->push_back(fs::path(p).relative_path().string());
				}
				return true;
			}
};
	
}
#endif
